package com.browsesoft.baseadapter;

import java.util.Collection;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.log4j.Logger;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;

import com.aote.component.format.FormatFactory;
import com.aote.entity.propertygather.PropertyGatherFactory;
import com.aote.expression.ExpressionGenerator;
import com.aote.mvc.event.EventProcessor;
import com.aote.util.EntityHelper;
import com.aote.util.StringHelper;
import com.aote.util.ThreadLocals;
import com.browsesoft.Entity;
import com.browsesoft.EntityManager;
import com.browsesoft.ExtendElement;
import com.browsesoft.SequenceFind;
import com.browsesoft.Tools;
import com.browsesoft.htmlcomponent.HTMLBasicComponent;
import com.browsesoft.htmlcomponent.HTMLFormComponent;
import com.browsesoft.htmlcomponent.HTMLPage;
import com.browsesoft.resource.Resource;
import com.browsesoft.tools.BSCalendar;
import com.browsesoft.user.User;

/**
 * 高级简单实体 1. 自动带系统日期 2. 自动带操作员名称 3. 可以根据输入的关键字从其他实体带内容 4. 可以根据传人的初始参数从其他实体带内容 5.
 * 当提交时，可以把本实体的内容原封不动的更新到其他实体中去 6.
 * 如果其他实体的内容要根据本实体内容进行逻辑处理，则必须继承，重载updateAttributes方法
 * 
 * 
 * 标签使用说明
 *
 * 4. 可以根据输入的关键字从其他实体带内容,
 * 
 */
public class AdvancedSimpleEntity extends SimpleEntity {
	/**
	 * 
	 */
	private static final long serialVersionUID = -705765815829695318L;

	/**
	 * 从另外对象取得的属性集
	 */
	protected Hashtable source = new Hashtable();

	/**
	 * 放所有实体以及其标识，key为标识，标识为属性名
	 */
	protected Map attributeEntitys = new HashMap();

	/**
	 * 事件处理器
	 */
	private transient EventProcessor eventProcessor;

	/**
	 * 保存请求，以便updateAttributes时可以使用
	 */
	protected HttpServletRequest request;

	// 原属性
	private Map oldAttrs;

	/**
	 */
	private Map partEntities = new HashMap();

	/**
	 * 子表实体开始加载时的实体，以后的修改过程不改变这部分内容，但是提交时要先删除旧的，然后添加新的
	 */
	private Map oldPartEntities = new HashMap();

	/**
	 * 空构造
	 */
	public AdvancedSimpleEntity() {
		super();
	}

	/**
	 * 构造
	 */
	public AdvancedSimpleEntity(Hashtable ht) {
		super(ht);
		this.loadPartEntities(ht);
	}

	/**
	 * 加载子实体列表
	 */
	private void loadPartEntities(Map ht) {
		// 对于每一个属性
		Iterator iter = ht.entrySet().iterator();
		while (iter.hasNext()) {
			Map.Entry entry = (Map.Entry) iter.next();
			String name = (String) entry.getKey();
			String value = (String) entry.getValue();
			// 如果是子列表属性，加载子列表
			if (name.startsWith("l_")) {
				List list = this.loadOnePartEntities(value);
				this.partEntities.put(name, list);
				// 保存旧的实体
				this.oldPartEntities.put(name, new LinkedList(list));
			}
		}
	}

	/**
	 * 加载一项自列表实体
	 */
	private List loadOnePartEntities(String value) {
		List result = new LinkedList();
		// 对于每一个 id:entity对
		Iterator iter = StringHelper.parseAttributes(value).entrySet()
				.iterator();
		while (iter.hasNext()) {
			Map.Entry entry = (Map.Entry) iter.next();
			String id = (String) entry.getKey();
			String type = (String) entry.getValue();
			// 加载对象
			String cond = "id='" + id + "'";
			Collection list = EntityManager.getInstance().getEntities(type,
					cond);
			if (list.size() != 1) {
				throw new RuntimeException("加载部分实体出错：entity=" + this.entityType
						+ ",parentid=" + this.getID() + ",childid=" + id
						+ "childentity=" + type);
			}
			Entity entity = (Entity) list.iterator().next();
			result.add(entity);
		}
		return result;
	}

	/**
	 * 处理请求
	 */
	public void service(HttpServletRequest request, HttpServletResponse response)
			throws Exception {
		super.service(request, response);
		this.request = request;
		// 保留旧属性 以便带数据时检查属性是否发生了变化
		this.oldAttrs = new HashMap(this.attributes);
		// 取得模板名
		String templatename = request.getParameter("templatename");
		if (templatename != null) {
			// 更新系统时间和用户名
			updateSystem(this.attributes);
		}
		// 获得动作参数
		action = request.getParameter("action");
		// 组建的元素
		Element componentElement = this.BasicComponent.getElement();
		this.expressionDispose();
		// 刷新时不根据请求取数据源，因为其它带值动作已经带过值了
		if (action == null || !action.equals("refresh")) {
			// 从页面上获得数据的来源
			this.getSource(componentElement, request);
		}
	}

	/**
	 * 取实体
	 * 
	 * @param name
	 *            参数名
	 * @param param
	 *            参数值
	 * @param request
	 *            子类可能要从中取附件信息
	 * @return 实体列表
	 */
	protected Entity getEntity(HttpServletRequest request, String name,
			String param) {
		try {
			// 得到entitytype属性
			Element e = (Element) ExtendElement.findElements(
					this.getComponent().getElement(), "name", name).iterator()
					.next();
			String entityType = e.getAttribute("entitytype");
			Iterator ls = null;
			// 如果有实体类型
			if (entityType != null && !entityType.equals("")) {
				// 按实体类型装载
				ls = EntityManager.getInstance().getEntities(entityType, name,
						param, this.BasicComponent.getPage()).iterator();
			}
			// 否则
			else {
				// 按类装载
				ls = EntityManager.getInstance().getObjects(
						"com.browsesoft.baseadapter.BasicEntity", name, param)
						.iterator();
			}
			if (ls.hasNext()) {
				// 取实体
				return (Entity) ls.next();
			}
			return null;
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	/**
	 * 更新属性
	 * 
	 * @param hashtable
	 *            属性集
	 * @throws Exception
	 */
	public void updateAttributes(Hashtable hashtable) throws Exception {
		super.updateAttributes(hashtable);
		// 在实体插入时，如果有相关对象集合处理标记
		if (this.isShouldInsert()) {
			updateOtherObjListAttr("insert");
			// 更新相关对象
			this.updateOtherObjects(removeInitAttributes(this.attributes));
		}
		// 处理废弃编号收回
		String otherAction = request.getParameter("otheraction");
		if (otherAction != null && !otherAction.equals("")) {
			this.eventProcessor.processEvent(otherAction, this.request,
					hashtable);
		}
		// 如果是连续添加
		if (this.isNext()) {
			// 收集属性
			Hashtable newAttrs = PropertyGatherFactory.getInstance()
					.getPropertys(this.BasicComponent.getElement(),
							this.attributes);
			this.attributes = newAttrs;
			String id = Integer.toString(SequenceFind.getID());
			this.attributes.put("id", id);
			// 清空带值实体
			this.attributeEntitys.clear();
			this.source.clear();
		}
	}

	/**
	 * 处理属性
	 */
	protected void processAttributes(Hashtable hashtable) {
		super.processAttributes(hashtable);
		// 如果不是只读，处理带数据过程，带数据时，必须检查属性是否发生变化，所以要在super之前运行
		if (!this.getComponent().isReadOnlyShow()) {
			this.getInitAttrByAttr(hashtable, oldAttrs);
		}
		// 默认值处理
		expressionDispose();
		// 产生了事件，根据事件执行动作
		if (this.action != null && !this.action.equals("")) {
			this.eventProcessor.processEvent(this.action, this.request,
					hashtable);
		}
		// 提交时，要进行格式化处理
		if (this.action != null
				&& (this.action.equals("confirm") || this.action.equals("next"))) {
			format();
		}
	}

	/**
	 * 格式化属性
	 */
	private void format() {
		HTMLFormComponent comp = (HTMLFormComponent) this.BasicComponent;
		// 对每一个要处理的元素
		Iterator iter = comp.getDealElements().iterator();
		while (iter.hasNext()) {
			Element e = (Element) iter.next();
			String name = e.getAttribute("name");
			String value = (String) this.getAttributes().get(name);
			// 对值进行格式化
			if (value == null) {
				continue;
			}
			value = FormatFactory.getInstance().format(value, e);
			this.attributes.put(name, value);
		}
	}

	/**
	 * 更新子表实体
	 */
	private void updatePartEntities() {
		try {
			// 对每一个属性，处理子实体
			Iterator iter = this.partEntities.entrySet().iterator();
			while (iter.hasNext()) {
				Map.Entry entry = (Map.Entry) iter.next();
				// 删除原有实体
				String name = (String) entry.getKey();
				List oldPartEntities = (List) this.oldPartEntities.get(name);
				EntityHelper.deleteEntities(oldPartEntities);
				// 插入新实体
				List entities = (List) entry.getValue();
				Iterator liter = entities.iterator();
				// 将子实体存库
				while (liter.hasNext()) {
					BasicEntity entity = (BasicEntity) liter.next();
					entity.saveOrUpdate();
				}
			}
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	/**
	 * 如果是连续添加
	 */
	private boolean isNext() {
		// 如果有parentID,并且action的值为"confirm"
		if (parentID != null && !parentID.equals("") && action != null
				&& action.equals("next")) {
			return true;
		}
		return false;
	}

	/**
	 * 默认值处理
	 */
	public void expressionDispose() {
		// 如果只读，且没有必须进行表达式计算标记，不进行表达式计算
		HTMLFormComponent fComponent = (HTMLFormComponent) this.BasicComponent;
		if (fComponent == null) {
			return;
		}
		if (fComponent.readOnlyShow
				&& !fComponent.getElement().hasAttribute("mustcompute")) {
			return;
		}
		Map values = ExpressionGenerator.getInstance().generateValues(
				this.getComponent().getElement(), this.attributes,
				this.loginUser, this.getComponent());
		if (values == null) {
			return;
		}
		Iterator iter = values.entrySet().iterator();
		// 保存处理结果
		while (iter.hasNext()) {
			Map.Entry entry = (Map.Entry) iter.next();
			if (entry.getValue() instanceof Collection) {
				// 如果结果是子实体，放入partEntity中
				this.setPartEntities((String) entry.getKey(), (List) entry
						.getValue());
			} else {
				// 否则放进attributes中
				this.attributes.put(entry.getKey(), entry.getValue());
			}
		}
	}

	/**
	 * 根据页面配置的集合处理标记进行处理
	 */
	private void updateOtherObjListAttr(String action) {
		// 如果是关联实体的集合处理标记
		NodeList list = this.BasicComponent.getElement().getElementsByTagName(
				"associateObjListAttr");
		if (list.getLength() > 0) {
			Element elem = (Element) list.item(0);
			// 每个关联对象进行集合处理
			Iterator iter = this.attributeEntitys.values().iterator();
			while (iter.hasNext()) {
				SimpleEntity entity = (SimpleEntity) iter.next();
				entity.ListAttrDispose(action, entity, elem);
			}
		}

	}

	/**
	 * 初始化初始属性
	 * 
	 * @return hashtable
	 */
	protected Hashtable initAttributes(Hashtable ht) {
		Iterator it = ht.keySet().iterator();
		// 对于每一个属性
		while (it.hasNext()) {
			String item = (String) it.next();
			// 得到_init位置
			int pos = item.indexOf("_init");
			// 如果存在
			if (pos != -1) {
				String itemValue = ht.get(item).toString();
				// 如果_init属性值为空
				if (itemValue.equals("")) {
					if (ht.get(item.substring(0, pos)) != null) {
						ht.put(item, ht.get(item.substring(0, pos)));
					}
				}
			}
		}
		return ht;
	}

	/**
	 * 删除_init属性
	 * 
	 * @return hashtable
	 */
	protected Hashtable removeInitAttributes(Hashtable ht) {
		Hashtable result = new Hashtable();
		Iterator it = ht.keySet().iterator();
		// 对于每一个属性
		while (it.hasNext()) {
			String item = (String) it.next();
			// 得到_init位置
			int pos = item.indexOf("_init");
			// 如果不存在
			if (pos == -1) {
				result.put(item, ht.get(item));
			}
		}
		return result;
	}

	/**
	 * 真正提交提示
	 */
	public void tipSuccess() {
		Element e = (Element) this.BasicComponent.getPage().getDocument()
				.getElementsByTagName("body").item(0);
		e
				.setAttribute("onload",
						"alert('提交成功!');opener.document.forms[0].submit();window.close()");
	}

	/**
	 * 得到初始属性
	 * 
	 */
	protected void getInitAttrByAttr(Map inputs, Map oldAttrs) {
		// 对于每一个源
		Iterator iter = this.attributeEntitys.entrySet().iterator();
		while (iter.hasNext()) {
			// 根据输入框名称找到实体
			Entry entry = (Entry) iter.next();
			String tag = (String) entry.getKey();
			Entity entity = (Entity) entry.getValue();
			// 如果实体不存在，不处理
			if (entity == null) {
				continue;
			}
			// 如果值没有变化，不处理
			if (!isChanged(inputs, oldAttrs, tag)) {
				continue;
			}
			// 处理本项来源
			this.dealOneSourceByAttr(tag, entity);
		}
	}

	/**
	 * 看请求的值是否发生了变化
	 */
	public boolean isChanged(Map inputs, Map oldAttrs, String name) {
		String rValue = (String) inputs.get(name);
		String aValue = (String) oldAttrs.get(name);
		// 如果属性中的值为空，肯定发生了变化
		if (aValue == null || aValue.equals("")) {
			return true;
		}
		// 如果请求中的值为空，没有发生变化
		else if (rValue == null || rValue.equals("")) {
			return false;
		}
		// 值不等即为发生了变化
		return !aValue.equals(rValue);
	}

	/**
	 * 处理一项来源
	 */
	public void dealOneSourceByAttr(String tag, Entity entity) {
		// 根据页面上的"classname"标记，找到要填充的值所在的类名
		Element element = this.getComponent().getElement();
		Iterator iter = ExtendElement.findElements(element, "source", tag)
				.iterator();
		// 对于每个要初始的值
		while (iter.hasNext()) {
			Element ee = (Element) iter.next();
			dealOneValue(entity, ee);
		}
	}

	/**
	 * 处理一个取值过程
	 * 
	 * @param entity
	 * @param ee
	 */
	private void dealOneValue(Entity entity, Element ee) {
		// 取得“name”标记的值
		String name = ee.getAttribute("name");
		// 取得“sourcename”标记的值
		String sourceName = ee.getAttribute("sourcename");
		// 如果没有sourceName
		if (sourceName == null || sourceName.equals("")) {
			sourceName = name;
		}
		// 如果是子对象列表，按子对象列表方式处理
		String entityType = ee.getAttribute("entitytype");
		if (entityType != null && !entityType.equals("")) {
			this.disposeEntity(name, sourceName, entityType, entity, ee);
			return;
		}
		// 获得“name”标记的值
		String value = (String) entity.getAttributes().get(sourceName);
		// 如果有值
		if (value != null) {
			// 放入结果集
			this.attributes.put(name, value);
			// 放入临时的集合中
			this.source.put(name, value);
		}
	}

	/**
	 * 
	 * @param name
	 * @param sourceName:数据来源的实体的标识名
	 * @param entityType：数据来源实体的实体类型
	 * @param entity：数据来源的实体
	 */
	private void disposeEntity(String name, String sourceName,
			String entityType, Entity entity, Element element) {
		try {
			// 找到源实体中的所有子实体
			List entityList = new LinkedList();
			String property = element.getAttribute("property");
			if (property == null || property.equals("")) {
				return;
			}
			if (this.isFindEntity(entity, property, name)) {
				return;
			}
			String sourceID = entity.getID();
			HTMLPage page = (HTMLPage) ThreadLocals.page.get();
			Iterator iter = EntityManager.getInstance().getEntities(entityType,
					sourceName, sourceID, page).iterator();
			while (iter.hasNext()) {
				// 将本实体自己的标识名和ID加到子实体中
				SimpleEntity ent = (SimpleEntity) iter.next();
				if (!this.checkEntity(ent, element)) {
					continue;
				}
				entityList.add(ent);
			}
			this.setPartEntities(name, entityList);
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	/**
	 * 核对实体是否符合条件
	 */
	private boolean checkEntity(Entity entity, Element element) {
		// 取查找实体的条件
		String condition = element.getAttribute("conditions");
		if (condition == null || condition.equals("")) {
			return true;
		}
		// 用条件和实体对应的属性相比较
		Iterator iter = StringHelper.parseAttributes(condition).entrySet()
				.iterator();
		while (iter.hasNext()) {
			Map.Entry entry = (Map.Entry) iter.next();
			String name = (String) entry.getKey();
			// 取实体的此属性进行比较
			String value = (String) entity.getAttributes().get(name);
			if (!value.equals(entry.getValue())) {
				return false;
			}
		}
		return true;
	}

	/**
	 * 根据属性列表找实体
	 */
	private boolean isFindEntity(Entity entity, String propertyList, String name) {
		if (propertyList == null || propertyList.equals("")
				|| !entity.getAttributes().containsKey(propertyList)) {
			return false;
		}
		String ids = (String) entity.getAttributes().get(propertyList);
		List list = this.loadOnePartEntities(ids);
		this.setPartEntities(name, list);
		return true;
	}

	private Entity getEntity(HttpServletRequest request, Element e) {
		Entity result = EntityHelper.createEntities(request, e, this
				.getComponent());
		if (result != null) {
			return result;
		}
		// 找到有“from”标记的元素，代表源对象的类名
		String className = e.getAttribute("from");
		if (className == null || className.equals("")) {
			return null;
		}
		// 源对象的名称
		String name = e.getAttribute("name");
		String input = getKeyValue(request, name);
		// 没有输入值，正常退出
		if (input == null || input.equals("")) {
			return null;
		}
		// 源对象属性名
		String sname = e.getAttribute("sourcename");
		// 如果有来源
		if (sname != null && !sname.equals("")) {
			name = sname;
		}
		// 得到实体
		Iterator it = this.getEntitys(e, name, className, input).iterator();
		// 如果没有找到实体，抛出实体未找到异常
		if (!it.hasNext()) {
			throw new EntityNotFoundException();
		}
		Entity entity = (Entity) it.next();
		return entity;
	}

	/**
	 * 得到所有数据来源所对应的实体,放到实体集合中
	 * 
	 * @param componentElement
	 *            组件元素
	 * @param request
	 *            请求
	 */
	protected void getSource(Element componentElement,
			HttpServletRequest request) {
		Element e = null;
		// 查找页面上有“sourec”标记的元素，即查找源数据
		Iterator iter = ExtendElement.findElements(componentElement, "source",
				"source").iterator();
		// 对于找到的所有来源
		while (iter.hasNext()) {
			try {
				e = (Element) iter.next();
				String name = e.getAttribute("name");
				// 把实体放到实体及其标识中去
				Entity entity = this.getEntity(request, e);
				if (entity == null) {
					if (e.hasAttribute("occasion")
							&& e.getAttribute("occasion").equals("everytime")) {
						this.attributes.remove(name);
						this.attributeEntitys.remove(name);
					}
					continue;
				}
				// 源对象属性名
				String sname = e.getAttribute("sourcename");
				if (sname != null && !sname.equals("")) {
					String value = (String) entity.getAttributes().get(sname);
					this.attributes.put(name, value);
				}
				this.attributeEntitys.put(name, entity);
			} catch (EntityNotFoundException ex) {
				if (!this.getComponent().isReadOnlyShow()) {
					// 设置提示信息
					String error = getErrorMessage(e);
					this.BasicComponent.getPage().showMessage(error);
				}
			} catch (Exception ex) {
				Logger.getLogger(this.getClass()).warn("带值错误", ex);
			}
		}
	}

	/**
	 * 得到提示信息
	 */
	private String getErrorMessage(Element e) {
		String error = e.getAttribute("errormessage");
		if (error != null && !error.equals("")) {
			return error;
		}
		return "alert('输入数据错误，请重新输入')";
	}

	/**
	 * 得到要带值对象的值，请求里没有，从属性里得。
	 * 
	 * @param request
	 * @param name
	 * @return
	 */
	private String getKeyValue(HttpServletRequest request, String name) {
		// 获得源对象的值
		String input = request.getParameter(name);
		if (input == null || input.equals("")) {
			input = (String) this.attributes.get(name);
		}
		return input;
	}

	/**
	 * 得到实体
	 * 
	 * @param hashtable
	 */
	private Collection getEntitys(Element e, String name, String className,
			String input) {
		try {
			// 得到实体类型
			String entityType = e.getAttribute("entitytype");
			// 如果有实体类型
			if (entityType != null && !entityType.equals("")) {
				// 根据页面上entitytype的值找到对象
				return EntityManager.getInstance().getEntities(entityType,
						name, input, this.BasicComponent.getPage());
			}
			// 否则
			else {
				// 根据页面上“sourcename”的值找到对象
				return EntityManager.getInstance().getObjects(className, name,
						input);
			}
		} catch (Exception ex) {
			throw new RuntimeException(ex);
		}
	}

	/**
	 * 更新系统时间和用户名
	 * 
	 * @param hashtable
	 */
	protected void updateSystem(Hashtable hashtable) throws Exception {
		// 在页面上找到操作员元素
		LinkedList ls = ExtendElement.findElements(this.BasicComponent
				.getElement(), "operator", "operator");
		Iterator iter = ls.iterator();
		while (iter.hasNext()) {
			Element e = (Element) iter.next();
			// 获得元素名称
			String name = e.getAttribute("name");
			if (hashtable.get(name) == null || hashtable.get(name).equals("")) {
				// 放入哈希表
				hashtable.put(name, this.loginUser.getAttributes().get("name"));
			}
		}
		// 从页面上找系统时间元素
		ls = ExtendElement.findElements(this.BasicComponent.getElement(),
				"systemtime", "systemtime");
		iter = ls.iterator();
		while (iter.hasNext()) {
			Element e = (Element) iter.next();
			// 获得元素名称
			String name = e.getAttribute("name");
			if (hashtable.get(name) == null || hashtable.get(name).equals("")) {
				// 放入哈希表
				hashtable.put(name, BSCalendar.now().toString());
			}
		}
		// 从页面上找当前时间元素
		ls = ExtendElement.findElements(this.BasicComponent.getElement(),
				"time", "time");
		iter = ls.iterator();
		while (iter.hasNext()) {
			Element e = (Element) iter.next();
			// 获得元素名称
			String name = e.getAttribute("name");
			if (hashtable.get(name) == null || hashtable.get(name).equals("")) {
				// 放入哈希表
				hashtable.put(name, Tools.getTimeOfToday().substring(11, 19));
			}
		}
		// 在页面上找到有默认值的元素
		ls = ExtendElement.findElementsOfAttr(this.BasicComponent.getElement(),
				"defaultvalue");
		iter = ls.iterator();
		while (iter.hasNext()) {
			Element e = (Element) iter.next();
			// 获得元素名称
			String name = e.getAttribute("name");
			if (hashtable.get(name) == null || hashtable.get(name).equals("")) {
				// 放入哈希表
				hashtable.put(name, e.getAttribute("defaultvalue"));
			}
		}
		// 得到带organizationname=organizationname标记的元素
		ls = ExtendElement.findElements(this.BasicComponent.getElement(),
				"organizationname", "organizationname");
		iter = ls.iterator();
		while (iter.hasNext()) {
			Element e = (Element) iter.next();
			// 获得元素名称
			String name = e.getAttribute("name");
			if (hashtable.get(name) == null || hashtable.get(name).equals("")) {
				// 放入哈希表
				hashtable.put(name, this.getOrgName(loginUser));
			}
		}
	}

	/**
	 * 得到第一级别的组织ID
	 * 
	 * @param user
	 *            当前用户
	 * @return ID号
	 */
	protected String getOrgName(User user) {
		// 得到登录用户的父
		Resource parent = user.getParent();
		LinkedList ls = new LinkedList();
		while (parent != null) {
			ls.add(parent);
			parent = parent.getParent();
		}
		// 如果level不存在
		if (ls.size() - 1 < 1) {
			return "0";
		}
		parent = (Resource) ls.getFirst();
		return (String) parent.getAttributes().get("name");
	}

	/**
	 * 更新其他对象的属性
	 * 
	 * @param ht
	 * @throws Exception
	 */
	protected void updateOtherObjects(Hashtable ht) throws Exception {
		// 对于每个要更新的实体
		Iterator iter = this.attributeEntitys.entrySet().iterator();
		while (iter.hasNext()) {
			Entry entry = (Entry) iter.next();
			String ename = (String) entry.getKey();
			Entity entity = (Entity) entry.getValue();
			// 查找页面上有“target”标记的元素
			Element ce = this.BasicComponent.getElement();
			List list = ExtendElement.findElements(ce, "toclassname", ename);
			Iterator ls = list.iterator();
			// 对于每个找到的元素
			while (ls.hasNext()) {
				Element e = (Element) ls.next();
				writeReturnValue(ht, e, entity);
			}
			// 如果有回写内容，对象更新
			if (!list.isEmpty()) {
				entity.update();
			}
		}
	}

	/**
	 * 回写值，如果是子列表实体，要把自列表实体给回写的对象
	 * 
	 * @param ht
	 * @param e
	 * @param entity
	 */
	private void writeReturnValue(Hashtable ht, Element e, Entity entity) {
		// 获得“name”标记的值
		String name = e.getAttribute("name");
		// 获得“toname”标记的值
		String toName = e.getAttribute("toname");
		if (toName == null || toName.equals("")) {
			toName = name;
		}
		// 获得元素的值
		String value = (String) ht.get(name);
		// 如果value为空，置为空串
		if (value == null) {
			value = "";
		}
		// 如果是子列表实体
		String entityType = e.getAttribute("entitytype");
		if (entityType != null && !entityType.equals("")) {
			List partEntities = (List) this.partEntities.get(name);
			// 即带值又回写的简单对象也有entitytype属性，但是不是子列表实体。
			// 找不到时，当作不是子列表实体处理。
			if (partEntities == null) {
				entity.getAttributes().put(toName, value);
			} else {
				AdvancedSimpleEntity aEntity = (AdvancedSimpleEntity) entity;
				aEntity.setPartEntities(toName, partEntities);
			}
		} else {
			entity.getAttributes().put(toName, value);
		}
	}

	/**
	 * 根据名称，得到回写实体
	 */
	public Entity getEntity(String name) {
		return (Entity) this.attributeEntitys.get(name);
	}

	/**
	 * 设置组件时，产生事件处理器
	 */
	public void setComponent(HTMLBasicComponent component) {
		super.setComponent(component);
		this.eventProcessor = new EventProcessor(component);
	}

	/**
	 * 添加关联对象
	 * 
	 * @param name -
	 *            对应的关联对象的名称
	 * @param entity -
	 *            关联对象
	 */
	public void setAssociateEntity(String name, Entity entity) {
		this.attributeEntitys.put(name, entity);
		// 得到属性，给高级简单实体的属性赋值
		String value = (String) entity.getAttributes().get(name);
		if (value != null) {
			this.attributes.put(name, value);
		}
		this.dealOneSourceByAttr(name, entity);
	}

	/**
	 * 得到子列表对象
	 */
	public List getPartEntities(String name) {
		List result = (List) this.partEntities.get(name);
		return result;
	}

	/**
	 * 设置子对象，设置时复制并转换对象的父id号
	 */
	public void setPartEntities(String name, List entities) {
		List nEntities = new LinkedList();
		Iterator iter = entities.iterator();
		while (iter.hasNext()) {
			SimpleEntity ent = (SimpleEntity) iter.next();
			// 复制一个实体到列表中
			SimpleEntity centity = (SimpleEntity) ent.clone();
			// 设置子表实体的父id为本实体id
			centity.getAttributes().put("parentid", this.getID());
			nEntities.add(centity);
		}
		String ids = EntityHelper.entitiesToMaps(nEntities);
		this.attributes.put(name, ids);
		this.partEntities.put(name, nEntities);
	}

	/**
	 * 插入或者更新时，把一对多关系插入数据库，原来的一对多关系由赋值对象保证清除
	 */
	public void update() throws Exception {
		super.update();
		this.updatePartEntities();
	}

	public void insert() throws Exception {
		super.insert();
		this.updatePartEntities();
	}

	/**
	 * 更新页面元素
	 * 
	 * @param hTMLBasicComponent
	 *            基本组件
	 * @throws Exception
	 */
	public void updatePageElement(HTMLBasicComponent hTMLBasicComponent)
			throws Exception {
		super.updatePageElement(hTMLBasicComponent);
	}

	public Map getOldAttrs() {
		return oldAttrs;
	}

	public Map formatDatas(Map datas) {
		Map result = new HashMap();
		Element element = this.BasicComponent.getElement();
		Iterator iter = datas.entrySet().iterator();
		while (iter.hasNext()) {
			Map.Entry entry = (Map.Entry) iter.next();
			String name = (String) entry.getKey();
			String value = (String) entry.getValue();
			LinkedList list = ExtendElement.findElements(element, "name", name);
			if (list == null || list.size() == 0) {
				result.put(name, value);
			} else {
				Element elem = (Element) list.getFirst();
				String str = FormatFactory.getInstance().format(value, elem);
				result.put(name, str);
			}
		}
		return result;
	}
}